// 2_26_proist.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include<deque>
#include<queue>
#include<assert.h>
using namespace std;
#include "queue.h"
#include"stack.h"
#include "Priority_queue.h"

//int main()
//{
//    //队列，先进先出
//    my_queue::queue<int> q1;
//    q1.push(1);
//    q1.push(2);
//    q1.push(3);
//    q1.push(4);
//    q1.pop();
//    cout << q1.size() << endl;
//    cout << q1.front() << endl;
//    cout << q1.back() << endl;
//
//    my_stack::Stack<int> s1;
//    s1.push(2);
//    s1.push(3);
//    s1.push(4);
//    s1.push(5);
//    s1.pop();
//    cout << s1.top() << endl;
//
//    
//    
//    return 0;
//}

//int main()
//{
//	//my_priority::priority_queue<int> p;   //大堆
//	my_priority::priority_queue<int,vector<int>,greater<int>> p;  //小堆
//
//	p.push(1);
//	p.push(5);
//	p.push(3);
//	p.push(2);
//	p.push(10);
//	cout << p.size() << endl;
//	while(!p.empty())
//	{
//		cout << p.top() << " ";
//		p.pop();
//	}
//
//
//
//	return 0;
//}



//

//class MyStack {
//public:
//    MyStack() {
//
//    }
//
//    void push(int x) {
//        if (!q1.empty())
//        {
//            q2.push(q1.front());
//            q1.pop();
//        }
//        q1.push(x);
//    }
//
//    int pop() {
//        assert(q1.size() == 0);
//            
//        int a = q1.front();
//        q1.pop();
//        while (!q2.empty())
//        {
//            q1.push(q2.front());
//            q2.pop();
//        }
//        while (q1.size() != 1)
//        {
//            q2.push(q1.front());
//            q1.pop();
//        }
//        return a;
//    }
//
//    int top() {
//        return q1.front();
//    }
//
//    bool empty() {
//        return q1.empty() && q2.empty();
//    }
//private:
//    queue<int> q1;
//    queue<int> q2;
//};
//int main()
//{
//    MyStack a;
//    a.push(1);
//    a.push(2);
//    a.push(3);
//    a.push(4);
//    cout << a.pop() << endl;
//    cout << a.top() << endl;
//    cout << a.pop() << endl;
//    cout << a.pop() << endl;
//    cout << a.pop() << endl;
//
//
//	return 0;
//}
//


////////仿函数/函数对象--->要求必须重载括号
////// ////仿函数/函数对象
//namespace yechao {
//	template<class T>
//	class less
//	{
//	public:
//		bool operator()(const T& x,const T& y)
//		{
//			return x < y;
//		}
//	};
//
//
//	template<class T>
//	class greater
//	{
//	public:
//		bool operator()(const T& x, const T& y)
//		{
//			return x > y;
//		}
//	};
//
//}
//
//template <class T,class Compare>
//void BubbleSort(T* a, int n, Compare com)   //本质是一个逻辑泛型  没有成员变量的类只有一个字节，传值传参很小
//{
//	for (int i = 0; i < n; i++)
//	{
//		int exchange = 0;
//		for (int j = 0; j < n - 1 - i; j++)
//		{
//			//if (a[j + 1] < a[j])
//			if(com(a[j+1],a[j]))
//			{
//				swap(a[j + 1], a[j]);
//				exchange = 1;
//			}
//		}
//		if (exchange == 0)
//		{
//			break;
//		}
//	}
//
//}
//
//int main()
//{
//	yechao::greater<int> greaterfun;  //greaterfun(1,2)等价于  greaterfun.operator()(1, 2);
//	yechao::less<int> lessfun;
//	int a[] = { 9,2,5,3,8,1,0,3 };
//	BubbleSort(a, sizeof(a) / sizeof(a[0]), greaterfun);
//	for (auto e : a)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//
//	BubbleSort(a, sizeof(a) / sizeof(a[0]), lessfun);
//	for (auto e : a)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	return 0;
//}

class Date {
public:

	Date(int year=0,int month=0,int day=0)
		:_year(year)
		,_month(month)
		,_day(day)
	{

	}
	bool operator<(const Date& d) const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month&& _day<d._day);
	}

	bool operator>(const Date& d) const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month&& _day > d._day);
	}

	friend ostream& operator<<(ostream& out, const Date& d) 
	{
		out << d._year << "-" << d._month << "-" << d._day;
		return out;
	}
private:
	int _year;
	int _month;
	int _day;
};

//对于指针而言，比较的不能是地址，只能是指针指向的值，所以需要解引用进行比较
struct PdateLess {
	bool operator()(const Date* d1, const Date* d2)
	{
		return *d1 < *d2;
	}
};

struct PdateGreater {
	bool operator()(const Date* d1, const Date* d2)
	{
		return *d1 > *d2;
	}
};

void TetsPriorityQueue()
{
	priority_queue<Date> q1;     //less --->大堆
	q1.push(Date(2018, 10, 29));
	q1.push(Date(2018, 10, 28));
	q1.push(Date(2018, 10, 30));
	cout << q1.top() << endl;

	//如果日期类不支持比较大小；第一：在日期类内部解决  第二：在大于小于的时候进行比较
	priority_queue<Date, vector<Date>,greater<Date>> q2;   //greater---->小堆
	q2.push(Date(2018, 10, 29));
	q2.push(Date(2018, 10, 31));
	q2.push(Date(2018, 10, 30));
	cout << q2.top() << endl;

	priority_queue<Date*,vector<Date*>,PdateLess> q3;     //less --->大堆
	q3.push(new Date(2018, 10, 29));
	q3.push(new Date(2018, 10, 28));
	q3.push(new Date(2018, 10, 30));
	cout << *q3.top() << endl;

	//如果日期类不支持比较大小；第一：在日期类内部解决  第二：在大于小于的时候进行比较
	priority_queue<Date*, vector<Date*>, PdateGreater> q4;   //greater---->小堆
	q4.push(new Date(2018, 10, 29));
	q4.push(new Date(2018, 10, 31));
	q4.push(new Date(2018, 10, 30));
	cout << *q4.top() << endl;

}


int main()
{
	TetsPriorityQueue();
	return 0;
}